spirv_cross.native source code

1 module spirv_cross.native;
2 
3 package:
4 
5 import spirv_cross;
6 static import spv;
7 
8 extern (C) nothrow:
9 
10 void* sc_d_gc_alloc(in size_t sz)
11 {
12     import core.memory : GC;
13 
14     return GC.malloc(sz);
15 }
16 
17 struct ScCompiler;
18 struct ScCompilerGlsl;
19 
20 struct ScGcCallbacks
21 {
22     extern (C) nothrow void* function(in size_t sz) alloc;
23 }
24 
25 extern (D) @property auto gcCallbacks()
26 {
27     return ScGcCallbacks(&sc_d_gc_alloc);
28 }
29 
30 enum ScResult
31 {
32     success,
33     compilationError,
34     error,
35     unhandled,
36 }
37 
38 extern (D) ScCompilerGlsl* sc_compiler_as_glsl(ScCompiler* compiler)
39 {
40     return cast(ScCompilerGlsl*) compiler;
41 }
42 
43 extern (D) ScCompiler* sc_compiler_glsl_as_base(ScCompilerGlsl* compiler)
44 {
45     return cast(ScCompiler*) compiler;
46 }
47 
48 // generic compiler functions
49 
50 void sc_compiler_delete(ScCompiler* compiler);
51 
52 string sc_compiler_get_error_string(const(ScCompiler)* compiler);
53 
54 ScResult sc_compiler_compile(ScCompiler* compiler, out string result);
55 
56 ScResult sc_compiler_get_name(const(ScCompiler)* compiler, uint id, out string result);
57 
58 ScResult sc_compiler_set_decoration(ScCompiler* compiler, uint id,
59         spv.Decoration decoration, uint argument);
60 
61 ScResult sc_compiler_set_decoration_string(ScCompiler* compiler, uint id,
62         spv.Decoration dec, string str);
63 
64 ScResult sc_compiler_set_name(ScCompiler* compiler, uint id, string str);
65 
66 // get_decoration_bitset
67 
68 ScResult sc_compiler_has_decoration(const(ScCompiler)* compiler, uint id,
69         spv.Decoration decoration, out bool result);
70 
71 ScResult sc_compiler_get_decoration(const(ScCompiler)* compiler, uint id,
72         spv.Decoration decoration, out uint result);
73 
74 ScResult sc_compiler_get_decoration_string(const(ScCompiler)* compiler, uint id,
75         spv.Decoration decoration, out string result);
76 
77 ScResult sc_compiler_unset_decoration(ScCompiler* compiler, uint id, spv.Decoration decoration);
78 
79 ScResult sc_compiler_get_type(const(ScCompiler)* compiler, uint id, out const(SPIRType)* result);
80 
81 ScResult sc_compiler_get_type_from_variable(const(ScCompiler)* compiler,
82         uint id, out const(SPIRType)* result);
83 
84 ScResult sc_compiler_get_non_pointer_type_id(const(ScCompiler)* compiler,
85         uint type_id, out uint result);
86 
87 ScResult sc_compiler_get_non_pointer_type(const(ScCompiler)* compiler, uint id,
88         out const(SPIRType)* result);
89 
90 // is_sampled_image type to be implemented in D
91 
92 ScResult sc_compiler_get_storage_class(const(ScCompiler)* compiler, uint id,
93         out spv.StorageClass result);
94 
95 ScResult sc_compiler_get_fallback_name(const(ScCompiler)* compiler, uint id, out string result);
96 
97 ScResult sc_compiler_get_block_fallback_name(const(ScCompiler)* compiler, uint id, out string result);
98 
99 ScResult sc_compiler_get_member_name(const(ScCompiler)* compiler, uint id,
100         uint index, out string result);
101 
102 ScResult sc_compiler_get_member_decoration(const(ScCompiler)* compiler, uint id,
103         uint index, spv.Decoration decoration, out uint result);
104 
105 ScResult sc_compiler_get_member_decoration_string(const(ScCompiler)* compiler,
106         uint id, uint index, spv.Decoration decoration, out string result);
107 
108 ScResult sc_compiler_set_member_name(ScCompiler* compiler, uint id, uint index, const string name);
109 
110 ScResult sc_compiler_get_member_qualified_name(const(ScCompiler)* compiler,
111         uint id, uint index, out string result);
112 
113 ScResult sc_compiler_set_member_qualified_name(ScCompiler* compiler, uint id,
114         uint index, string name);
115 
116 // get_member_decoration_bitset
117 
118 ScResult sc_compiler_has_member_decoration(const(ScCompiler)* compiler, uint id,
119         uint index, spv.Decoration decoration, out bool result);
120 
121 ScResult sc_compiler_set_member_decoration(ScCompiler* compiler, uint id,
122         uint index, spv.Decoration decoration, uint arg);
123 
124 ScResult sc_compiler_set_member_decoration_string(ScCompiler* compiler, uint id,
125         uint index, spv.Decoration decoration, string arg);
126 
127 ScResult sc_compiler_unset_member_decoration(ScCompiler* compiler, uint id,
128         uint index, spv.Decoration decoration);
129 
130 // get_fallback_member_name in D
131 
132 ScResult sc_compiler_get_active_buffer_ranges(const(ScCompiler)* compiler,
133         uint id, out BufferRange[] result);
134 
135 ScResult sc_compiler_get_declared_struct_size(const(ScCompiler)* compiler,
136         const(SPIRType)* type, out size_t result);
137 
138 ScResult sc_compiler_get_declared_struct_size_runtime_array(const(ScCompiler)* compiler,
139         const(SPIRType)* type, size_t array_size, out size_t result);
140 
141 ScResult sc_compiler_get_declared_struct_member_size(const(ScCompiler)* compiler,
142         const(SPIRType)* type, uint index, out size_t result);
143 
144 ScResult sc_compiler_get_active_interface_variables(const(ScCompiler)* compiler, out uint[] result);
145 
146 ScResult sc_compiler_set_enabled_interface_variables(ScCompiler* compiler,
147         const(uint)[] active_variables);
148 
149 ScResult sc_compiler_get_shader_resources(const(ScCompiler)* compiler, out ShaderResources result);
150 
151 ScResult sc_compiler_get_shader_resources_for_vars(const(ScCompiler)* compiler,
152         const(uint)[] active_variables, out ShaderResources result);
153 
154 ScResult sc_compiler_set_remapped_variable_state(ScCompiler* compiler, uint id, bool remap_enable);
155 
156 ScResult sc_compiler_get_remapped_variable_state(const(ScCompiler)* compiler, uint id,
157         out bool result);
158 
159 ScResult sc_compiler_set_subpass_input_remapped_components(ScCompiler* compiler,
160         uint id, uint components);
161 
162 ScResult sc_compiler_get_subpass_input_remapped_components(
163         const(ScCompiler)* compiler, uint id, out uint result);
164 
165 ScResult sc_compiler_get_entry_points_and_stages(const(ScCompiler)* compiler, out EntryPoint[] result);
166 
167 ScResult sc_compiler_set_entry_point(ScCompiler* compiler, string entry,
168         spv.ExecutionModel excution_model);
169 
170 ScResult sc_compiler_rename_entry_point(ScCompiler* compiler, string old_name,
171         string new_name, spv.ExecutionModel execution_model);
172 
173 // get_entry_point?
174 
175 ScResult sc_compiler_get_cleansed_entry_point_name(const(ScCompiler)* compiler,
176         string name, spv.ExecutionModel execution_model, out string result);
177 
178 // execution_mod_bitset
179 
180 ScResult sc_compiler_unset_execution_mode(ScCompiler* compiler, spv.ExecutionMode mode);
181 
182 ScResult sc_compiler_set_execution_mode(ScCompiler* compiler,
183         spv.ExecutionMode execution_mode, uint arg0, uint arg1, uint arg2);
184 
185 ScResult sc_compiler_get_execution_mode_argument(const(ScCompiler)* compiler,
186         spv.ExecutionMode execution_mode, uint index, out uint result);
187 
188 ScResult sc_compiler_get_execution_model(const(ScCompiler)* compiler, out spv.ExecutionModel result);
189 
190 ScResult sc_compiler_get_work_group_size_specialization_constants(const(ScCompiler)* compiler,
191         out SpecializationConstant x, out SpecializationConstant y,
192         out SpecializationConstant z, out uint result);
193 
194 ScResult sc_compiler_build_dummy_sampler_for_combined_images(ScCompiler* compiler, out uint result);
195 
196 ScResult sc_compiler_build_combined_image_samples(ScCompiler* compiler);
197 
198 ScResult sc_compiler_get_combined_image_samplers(const(ScCompiler)* compiler,
199         out CombinedImageSampler[] result);
200 
201 // remap_callback
202 
203 ScResult sc_compiler_get_specialization_constants(const(ScCompiler)* compiler,
204         out SpecializationConstant[] result);
205 
206 // get_constant
207 
208 ScResult sc_compiler_get_current_id_bound(const(ScCompiler)* compiler, out uint result);
209 
210 ScResult sc_compiler_type_struct_member_offset(const(ScCompiler)* compiler,
211         const(SPIRType)* type, uint index, out uint result);
212 
213 ScResult sc_compiler_type_struct_member_array_stride(const(ScCompiler)* compiler,
214         const(SPIRType)* type, uint index, out uint result);
215 
216 ScResult sc_compiler_type_struct_member_matrix_stride(const(ScCompiler)* compiler,
217         const(SPIRType)* type, uint index, out uint result);
218 
219 ScResult sc_compiler_get_binary_offset_for_decoration(const(ScCompiler)* compiler,
220         uint id, spv.Decoration decoration, out uint word_offset, out bool result);
221 
222 ScResult sc_compiler_buffer_is_hlsl_counter_buffer(const(ScCompiler)* compiler,
223         uint id, out bool result);
224 
225 ScResult sc_compiler_buffer_get_hlsl_counter_buffer(const(ScCompiler)* compiler,
226         uint id, out uint counter_id, out bool result);
227 
228 ScResult sc_compiler_get_declared_capabilities(const(ScCompiler)* compiler,
229         out spv.Capability[] result);
230 
231 ScResult sc_compiler_get_declared_extensions(const(ScCompiler)* compiler, out string[] result);
232 
233 ScResult sc_compiler_get_remapped_declared_block_name(const(ScCompiler)* compiler,
234         uint id, out string result);
235 
236 // buffer_block_flags
237 
238 // GLSL compiler funcs
239 
240 ScResult sc_compiler_glsl_new(const(uint)[] ir, ScGcCallbacks gc_callbacks,
241         out ScCompilerGlsl* result, out string error);
242 
243 ScResult sc_compiler_glsl_get_options(const(ScCompilerGlsl)* compiler, out ScOptionsGlsl result);
244 
245 ScResult sc_compiler_glsl_set_options(ScCompilerGlsl* compiler, const(ScOptionsGlsl)* options);
246 
247 ScResult sc_compiler_glsl_get_partial_source(ScCompilerGlsl* compiler, out string result);
248 
249 ScResult sc_compiler_glsl_add_header_line(ScCompilerGlsl* compiler, string str);
250 
251 ScResult sc_compiler_glsl_require_extension(ScCompilerGlsl* compiler, string ext);
252 
253 ScResult sc_compiler_glsl_flatten_buffer_block(ScCompilerGlsl* compiler, uint id);